"""
__build_back_S2S_MDL.py_____________________________________________________

Automatically generated AToM3 Model File (Do not modify directly)
Author: levi
Modified: Mon Dec  3 16:25:26 2012
____________________________________________________________________________
"""
from stickylink import *
from widthXfillXdecoration import *
from MT_pre__Station_S import *
from MT_pre__MatchModel import *
from MT_pre__ApplyModel import *
from MT_pre__Station_T import *
from MT_pre__match_contains import *
from MT_pre__apply_contains import *
from MT_pre__backward_link import *
from MT_post__match_contains import *
from MT_post__MatchModel import *
from MT_post__apply_contains import *
from MT_post__backward_link import *
from MT_post__ApplyModel import *
from MT_post__Station_S import *
from MT_post__Station_T import *
from NAC import *
from RHS import *
from LHS import *
from graph_MT_post__Station_T import *
from graph_MT_post__match_contains import *
from graph_MT_pre__apply_contains import *
from graph_LHS import *
from graph_MT_post__ApplyModel import *
from graph_MT_pre__Station_S import *
from graph_MT_pre__match_contains import *
from graph_MT_pre__MatchModel import *
from graph_MT_pre__ApplyModel import *
from graph_MT_post__MatchModel import *
from graph_MT_pre__backward_link import *
from graph_MT_post__apply_contains import *
from graph_MT_post__backward_link import *
from graph_MT_pre__Station_T import *
from graph_MT_post__Station_S import *
from graph_RHS import *
from graph_NAC import *
from ATOM3Enum import *
from ATOM3String import *
from ATOM3BottomType import *
from ATOM3Constraint import *
from ATOM3Attribute import *
from ATOM3Float import *
from ATOM3List import *
from ATOM3Link import *
from ATOM3Connection import *
from ATOM3Boolean import *
from ATOM3Appearance import *
from ATOM3Text import *
from ATOM3Action import *
from ATOM3Integer import *
from ATOM3Port import *
from ATOM3MSEnum import *

def build_back_S2S_MDL(self, rootNode, MT_pre__SimpleDSLTransRootNode=None, MT_post__SimpleDSLTransRootNode=None, MoTifRuleRootNode=None):

    # --- Generating attributes code for ASG MT_pre__SimpleDSLTrans ---
    if( MT_pre__SimpleDSLTransRootNode ): 
        # author
        MT_pre__SimpleDSLTransRootNode.author.setValue('Annonymous')

        # description
        MT_pre__SimpleDSLTransRootNode.description.setValue('\n')
        MT_pre__SimpleDSLTransRootNode.description.setHeight(15)

        # name
        MT_pre__SimpleDSLTransRootNode.name.setValue('')
        MT_pre__SimpleDSLTransRootNode.name.setNone()
    # --- ASG attributes over ---


    # --- Generating attributes code for ASG MT_post__SimpleDSLTrans ---
    if( MT_post__SimpleDSLTransRootNode ): 
        # author
        MT_post__SimpleDSLTransRootNode.author.setValue('Annonymous')

        # description
        MT_post__SimpleDSLTransRootNode.description.setValue('\n')
        MT_post__SimpleDSLTransRootNode.description.setHeight(15)

        # name
        MT_post__SimpleDSLTransRootNode.name.setValue('')
        MT_post__SimpleDSLTransRootNode.name.setNone()
    # --- ASG attributes over ---


    # --- Generating attributes code for ASG MoTifRule ---
    if( MoTifRuleRootNode ): 
        # author
        MoTifRuleRootNode.author.setValue('Annonymous')

        # description
        MoTifRuleRootNode.description.setValue('\n')
        MoTifRuleRootNode.description.setHeight(15)

        # name
        MoTifRuleRootNode.name.setValue('')
        MoTifRuleRootNode.name.setNone()
    # --- ASG attributes over ---


    self.obj16043=MT_pre__Station_S(self)
    self.obj16043.isGraphObjectVisual = True

    if(hasattr(self.obj16043, '_setHierarchicalLink')):
      self.obj16043._setHierarchicalLink(False)

    # MT_label__
    self.obj16043.MT_label__.setValue('3')

    # MT_pivotOut__
    self.obj16043.MT_pivotOut__.setValue('')
    self.obj16043.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj16043.MT_subtypeMatching__.setValue(('True', 0))
    self.obj16043.MT_subtypeMatching__.config = 0

    # MT_pre__name
    self.obj16043.MT_pre__name.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj16043.MT_pre__name.setHeight(15)

    # MT_pivotIn__
    self.obj16043.MT_pivotIn__.setValue('')
    self.obj16043.MT_pivotIn__.setNone()

    self.obj16043.graphClass_= graph_MT_pre__Station_S
    if self.genGraphics:
       new_obj = graph_MT_pre__Station_S(806.0,319.0,self.obj16043)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__Station_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj16043.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj16043)
    self.globalAndLocalPostcondition(self.obj16043, rootNode)
    self.obj16043.postAction( rootNode.CREATE )

    self.obj16044=MT_pre__Station_S(self)
    self.obj16044.isGraphObjectVisual = True

    if(hasattr(self.obj16044, '_setHierarchicalLink')):
      self.obj16044._setHierarchicalLink(False)

    # MT_label__
    self.obj16044.MT_label__.setValue('3')

    # MT_pivotOut__
    self.obj16044.MT_pivotOut__.setValue('')
    self.obj16044.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj16044.MT_subtypeMatching__.setValue(('True', 0))
    self.obj16044.MT_subtypeMatching__.config = 0

    # MT_pre__name
    self.obj16044.MT_pre__name.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj16044.MT_pre__name.setHeight(15)

    # MT_pivotIn__
    self.obj16044.MT_pivotIn__.setValue('')
    self.obj16044.MT_pivotIn__.setNone()

    self.obj16044.graphClass_= graph_MT_pre__Station_S
    if self.genGraphics:
       new_obj = graph_MT_pre__Station_S(240.0,320.0,self.obj16044)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__Station_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj16044.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj16044)
    self.globalAndLocalPostcondition(self.obj16044, rootNode)
    self.obj16044.postAction( rootNode.CREATE )

    self.obj16045=MT_pre__MatchModel(self)
    self.obj16045.isGraphObjectVisual = True

    if(hasattr(self.obj16045, '_setHierarchicalLink')):
      self.obj16045._setHierarchicalLink(False)

    # MT_label__
    self.obj16045.MT_label__.setValue('1')

    # MT_pivotOut__
    self.obj16045.MT_pivotOut__.setValue('')
    self.obj16045.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj16045.MT_subtypeMatching__.setValue(('True', 0))
    self.obj16045.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj16045.MT_pivotIn__.setValue('')
    self.obj16045.MT_pivotIn__.setNone()

    self.obj16045.graphClass_= graph_MT_pre__MatchModel
    if self.genGraphics:
       new_obj = graph_MT_pre__MatchModel(586.0,279.0,self.obj16045)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__MatchModel", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj16045.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj16045)
    self.globalAndLocalPostcondition(self.obj16045, rootNode)
    self.obj16045.postAction( rootNode.CREATE )

    self.obj16046=MT_pre__ApplyModel(self)
    self.obj16046.isGraphObjectVisual = True

    if(hasattr(self.obj16046, '_setHierarchicalLink')):
      self.obj16046._setHierarchicalLink(False)

    # MT_label__
    self.obj16046.MT_label__.setValue('2')

    # MT_pivotOut__
    self.obj16046.MT_pivotOut__.setValue('')
    self.obj16046.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj16046.MT_subtypeMatching__.setValue(('True', 0))
    self.obj16046.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj16046.MT_pivotIn__.setValue('')
    self.obj16046.MT_pivotIn__.setNone()

    self.obj16046.graphClass_= graph_MT_pre__ApplyModel
    if self.genGraphics:
       new_obj = graph_MT_pre__ApplyModel(586.0,419.0,self.obj16046)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__ApplyModel", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj16046.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj16046)
    self.globalAndLocalPostcondition(self.obj16046, rootNode)
    self.obj16046.postAction( rootNode.CREATE )

    self.obj16047=MT_pre__Station_T(self)
    self.obj16047.isGraphObjectVisual = True

    if(hasattr(self.obj16047, '_setHierarchicalLink')):
      self.obj16047._setHierarchicalLink(False)

    # MT_label__
    self.obj16047.MT_label__.setValue('4')

    # MT_pivotOut__
    self.obj16047.MT_pivotOut__.setValue('')
    self.obj16047.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj16047.MT_subtypeMatching__.setValue(('True', 0))
    self.obj16047.MT_subtypeMatching__.config = 0

    # MT_pre__name
    self.obj16047.MT_pre__name.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj16047.MT_pre__name.setHeight(15)

    # MT_pivotIn__
    self.obj16047.MT_pivotIn__.setValue('')
    self.obj16047.MT_pivotIn__.setNone()

    self.obj16047.graphClass_= graph_MT_pre__Station_T
    if self.genGraphics:
       new_obj = graph_MT_pre__Station_T(806.0,459.0,self.obj16047)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__Station_T", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj16047.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj16047)
    self.globalAndLocalPostcondition(self.obj16047, rootNode)
    self.obj16047.postAction( rootNode.CREATE )

    self.obj16048=MT_pre__Station_T(self)
    self.obj16048.isGraphObjectVisual = True

    if(hasattr(self.obj16048, '_setHierarchicalLink')):
      self.obj16048._setHierarchicalLink(False)

    # MT_label__
    self.obj16048.MT_label__.setValue('4')

    # MT_pivotOut__
    self.obj16048.MT_pivotOut__.setValue('')
    self.obj16048.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj16048.MT_subtypeMatching__.setValue(('True', 0))
    self.obj16048.MT_subtypeMatching__.config = 0

    # MT_pre__name
    self.obj16048.MT_pre__name.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj16048.MT_pre__name.setHeight(15)

    # MT_pivotIn__
    self.obj16048.MT_pivotIn__.setValue('')
    self.obj16048.MT_pivotIn__.setNone()

    self.obj16048.graphClass_= graph_MT_pre__Station_T
    if self.genGraphics:
       new_obj = graph_MT_pre__Station_T(240.0,460.0,self.obj16048)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__Station_T", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj16048.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj16048)
    self.globalAndLocalPostcondition(self.obj16048, rootNode)
    self.obj16048.postAction( rootNode.CREATE )

    self.obj16049=MT_pre__match_contains(self)
    self.obj16049.isGraphObjectVisual = True

    if(hasattr(self.obj16049, '_setHierarchicalLink')):
      self.obj16049._setHierarchicalLink(False)

    # MT_label__
    self.obj16049.MT_label__.setValue('5')

    # MT_pivotOut__
    self.obj16049.MT_pivotOut__.setValue('')
    self.obj16049.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj16049.MT_subtypeMatching__.setValue(('True', 0))
    self.obj16049.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj16049.MT_pivotIn__.setValue('')
    self.obj16049.MT_pivotIn__.setNone()

    self.obj16049.graphClass_= graph_MT_pre__match_contains
    if self.genGraphics:
       new_obj = graph_MT_pre__match_contains(767.0,340.0,self.obj16049)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__match_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj16049.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj16049)
    self.globalAndLocalPostcondition(self.obj16049, rootNode)
    self.obj16049.postAction( rootNode.CREATE )

    self.obj16050=MT_pre__apply_contains(self)
    self.obj16050.isGraphObjectVisual = True

    if(hasattr(self.obj16050, '_setHierarchicalLink')):
      self.obj16050._setHierarchicalLink(False)

    # MT_label__
    self.obj16050.MT_label__.setValue('6')

    # MT_pivotOut__
    self.obj16050.MT_pivotOut__.setValue('')
    self.obj16050.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj16050.MT_subtypeMatching__.setValue(('True', 0))
    self.obj16050.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj16050.MT_pivotIn__.setValue('')
    self.obj16050.MT_pivotIn__.setNone()

    self.obj16050.graphClass_= graph_MT_pre__apply_contains
    if self.genGraphics:
       new_obj = graph_MT_pre__apply_contains(769.0,480.0,self.obj16050)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__apply_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj16050.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj16050)
    self.globalAndLocalPostcondition(self.obj16050, rootNode)
    self.obj16050.postAction( rootNode.CREATE )

    self.obj16051=MT_pre__backward_link(self)
    self.obj16051.isGraphObjectVisual = True

    if(hasattr(self.obj16051, '_setHierarchicalLink')):
      self.obj16051._setHierarchicalLink(False)

    # MT_label__
    self.obj16051.MT_label__.setValue('7')

    # MT_pivotOut__
    self.obj16051.MT_pivotOut__.setValue('')
    self.obj16051.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj16051.MT_subtypeMatching__.setValue(('True', 0))
    self.obj16051.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj16051.MT_pivotIn__.setValue('')
    self.obj16051.MT_pivotIn__.setNone()

    self.obj16051.graphClass_= graph_MT_pre__backward_link
    if self.genGraphics:
       new_obj = graph_MT_pre__backward_link(301.0,431.0,self.obj16051)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__backward_link", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj16051.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj16051)
    self.globalAndLocalPostcondition(self.obj16051, rootNode)
    self.obj16051.postAction( rootNode.CREATE )

    self.obj16052=MT_post__match_contains(self)
    self.obj16052.isGraphObjectVisual = True

    if(hasattr(self.obj16052, '_setHierarchicalLink')):
      self.obj16052._setHierarchicalLink(False)

    # MT_label__
    self.obj16052.MT_label__.setValue('5')

    # MT_pivotOut__
    self.obj16052.MT_pivotOut__.setValue('')
    self.obj16052.MT_pivotOut__.setNone()

    self.obj16052.graphClass_= graph_MT_post__match_contains
    if self.genGraphics:
       new_obj = graph_MT_post__match_contains(1248.5,340.0,self.obj16052)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_post__match_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj16052.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj16052)
    self.globalAndLocalPostcondition(self.obj16052, rootNode)
    self.obj16052.postAction( rootNode.CREATE )

    self.obj16053=MT_post__MatchModel(self)
    self.obj16053.isGraphObjectVisual = True

    if(hasattr(self.obj16053, '_setHierarchicalLink')):
      self.obj16053._setHierarchicalLink(False)

    # MT_label__
    self.obj16053.MT_label__.setValue('1')

    # MT_pivotOut__
    self.obj16053.MT_pivotOut__.setValue('')
    self.obj16053.MT_pivotOut__.setNone()

    self.obj16053.graphClass_= graph_MT_post__MatchModel
    if self.genGraphics:
       new_obj = graph_MT_post__MatchModel(1066.0,279.0,self.obj16053)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_post__MatchModel", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj16053.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj16053)
    self.globalAndLocalPostcondition(self.obj16053, rootNode)
    self.obj16053.postAction( rootNode.CREATE )

    self.obj16054=MT_post__apply_contains(self)
    self.obj16054.isGraphObjectVisual = True

    if(hasattr(self.obj16054, '_setHierarchicalLink')):
      self.obj16054._setHierarchicalLink(False)

    # MT_label__
    self.obj16054.MT_label__.setValue('6')

    # MT_pivotOut__
    self.obj16054.MT_pivotOut__.setValue('')
    self.obj16054.MT_pivotOut__.setNone()

    self.obj16054.graphClass_= graph_MT_post__apply_contains
    if self.genGraphics:
       new_obj = graph_MT_post__apply_contains(1250.5,480.0,self.obj16054)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_post__apply_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj16054.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj16054)
    self.globalAndLocalPostcondition(self.obj16054, rootNode)
    self.obj16054.postAction( rootNode.CREATE )

    self.obj16055=MT_post__backward_link(self)
    self.obj16055.isGraphObjectVisual = True

    if(hasattr(self.obj16055, '_setHierarchicalLink')):
      self.obj16055._setHierarchicalLink(False)

    # MT_label__
    self.obj16055.MT_label__.setValue('7')

    # MT_pivotOut__
    self.obj16055.MT_pivotOut__.setValue('')
    self.obj16055.MT_pivotOut__.setNone()

    self.obj16055.graphClass_= graph_MT_post__backward_link
    if self.genGraphics:
       new_obj = graph_MT_post__backward_link(1347.0,430.0,self.obj16055)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_post__backward_link", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj16055.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj16055)
    self.globalAndLocalPostcondition(self.obj16055, rootNode)
    self.obj16055.postAction( rootNode.CREATE )

    self.obj16056=MT_post__ApplyModel(self)
    self.obj16056.isGraphObjectVisual = True

    if(hasattr(self.obj16056, '_setHierarchicalLink')):
      self.obj16056._setHierarchicalLink(False)

    # MT_label__
    self.obj16056.MT_label__.setValue('2')

    # MT_pivotOut__
    self.obj16056.MT_pivotOut__.setValue('')
    self.obj16056.MT_pivotOut__.setNone()

    self.obj16056.graphClass_= graph_MT_post__ApplyModel
    if self.genGraphics:
       new_obj = graph_MT_post__ApplyModel(1066.0,419.0,self.obj16056)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_post__ApplyModel", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj16056.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj16056)
    self.globalAndLocalPostcondition(self.obj16056, rootNode)
    self.obj16056.postAction( rootNode.CREATE )

    self.obj16057=MT_post__Station_S(self)
    self.obj16057.isGraphObjectVisual = True

    if(hasattr(self.obj16057, '_setHierarchicalLink')):
      self.obj16057._setHierarchicalLink(False)

    # MT_label__
    self.obj16057.MT_label__.setValue('3')

    # MT_pivotOut__
    self.obj16057.MT_pivotOut__.setValue('')
    self.obj16057.MT_pivotOut__.setNone()

    # MT_post__name
    self.obj16057.MT_post__name.setValue('\n#===============================================================================\n# You can access the value of the current node\'s attribute value by: attr_value.\n# If the current node shall be created you MUST initialize it here!\n# You can access a node labelled n by: PreNode(\'n\').\n# To access attribute x of node n, use: PreNode(\'n\')[\'x\'].\n# Note that the attribute values are those before the match is rewritten.\n# The order in which this code is executed depends on the label value\n# of the encapsulating node.\n# The given action must return the new value of the attribute.\n#===============================================================================\n\nreturn attr_value\n')
    self.obj16057.MT_post__name.setHeight(15)

    self.obj16057.graphClass_= graph_MT_post__Station_S
    if self.genGraphics:
       new_obj = graph_MT_post__Station_S(1286.0,319.0,self.obj16057)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_post__Station_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj16057.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj16057)
    self.globalAndLocalPostcondition(self.obj16057, rootNode)
    self.obj16057.postAction( rootNode.CREATE )

    self.obj16058=MT_post__Station_T(self)
    self.obj16058.isGraphObjectVisual = True

    if(hasattr(self.obj16058, '_setHierarchicalLink')):
      self.obj16058._setHierarchicalLink(False)

    # MT_label__
    self.obj16058.MT_label__.setValue('4')

    # MT_pivotOut__
    self.obj16058.MT_pivotOut__.setValue('')
    self.obj16058.MT_pivotOut__.setNone()

    # MT_post__name
    self.obj16058.MT_post__name.setValue('\n#===============================================================================\n# You can access the value of the current node\'s attribute value by: attr_value.\n# If the current node shall be created you MUST initialize it here!\n# You can access a node labelled n by: PreNode(\'n\').\n# To access attribute x of node n, use: PreNode(\'n\')[\'x\'].\n# Note that the attribute values are those before the match is rewritten.\n# The order in which this code is executed depends on the label value\n# of the encapsulating node.\n# The given action must return the new value of the attribute.\n#===============================================================================\n\nreturn attr_value\n')
    self.obj16058.MT_post__name.setHeight(15)

    self.obj16058.graphClass_= graph_MT_post__Station_T
    if self.genGraphics:
       new_obj = graph_MT_post__Station_T(1286.0,459.0,self.obj16058)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_post__Station_T", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj16058.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj16058)
    self.globalAndLocalPostcondition(self.obj16058, rootNode)
    self.obj16058.postAction( rootNode.CREATE )

    self.obj16059=NAC(self)
    self.obj16059.isGraphObjectVisual = True

    if(hasattr(self.obj16059, '_setHierarchicalLink')):
      self.obj16059._setHierarchicalLink(False)

    # constraint
    self.obj16059.constraint.setValue('#===============================================================================\n# This code is executed after the nodes in the NAC have been matched.\n# You can access a matched node labelled n by: PreNode(\'n\').\n# To access attribute x of node n, use: PreNode(\'n\')[\'x\'].\n# The given constraint must evaluate to a boolean expression:\n#    returning True forbids the rule from being applied,\n#    returning False enables the rule to be applied.\n#===============================================================================\n\nreturn True\n')
    self.obj16059.constraint.setHeight(15)

    self.obj16059.graphClass_= graph_NAC
    if self.genGraphics:
       new_obj = graph_NAC(100.0,220.0,self.obj16059)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("NAC", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj16059.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj16059)
    self.globalAndLocalPostcondition(self.obj16059, rootNode)
    self.obj16059.postAction( rootNode.CREATE )

    self.obj16060=RHS(self)
    self.obj16060.isGraphObjectVisual = True

    if(hasattr(self.obj16060, '_setHierarchicalLink')):
      self.obj16060._setHierarchicalLink(False)

    # action
    self.obj16060.action.setValue('#===============================================================================\n# This code is executed after the rule has been applied.\n# You can access a node labelled n matched by this rule by: PostNode(\'n\').\n# To access attribute x of node n, use: PostNode(\'n\')[\'x\'].\n#===============================================================================\n\npass\n')
    self.obj16060.action.setHeight(15)

    self.obj16060.graphClass_= graph_RHS
    if self.genGraphics:
       new_obj = graph_RHS(966.0,219.0,self.obj16060)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("RHS", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj16060.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj16060)
    self.globalAndLocalPostcondition(self.obj16060, rootNode)
    self.obj16060.postAction( rootNode.CREATE )

    self.obj16061=LHS(self)
    self.obj16061.isGraphObjectVisual = True

    if(hasattr(self.obj16061, '_setHierarchicalLink')):
      self.obj16061._setHierarchicalLink(False)

    # constraint
    self.obj16061.constraint.setValue('#===============================================================================\n# This code is executed after the nodes in the LHS have been matched.\n# You can access a matched node labelled n by: PreNode(\'n\').\n# To access attribute x of node n, use: PreNode(\'n\')[\'x\'].\n# The given constraint must evaluate to a boolean expression:\n#    returning True enables the rule to be applied,\n#    returning False forbids the rule from being applied.\n#===============================================================================\n\nreturn True\n')
    self.obj16061.constraint.setHeight(15)

    self.obj16061.graphClass_= graph_LHS
    if self.genGraphics:
       new_obj = graph_LHS(526.0,219.0,self.obj16061)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("LHS", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj16061.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj16061)
    self.globalAndLocalPostcondition(self.obj16061, rootNode)
    self.obj16061.postAction( rootNode.CREATE )

    # Connections for obj16043 (graphObject_: Obj124) of type MT_pre__Station_S
    self.drawConnections(
 )
    # Connections for obj16044 (graphObject_: Obj125) of type MT_pre__Station_S
    self.drawConnections(
 )
    # Connections for obj16045 (graphObject_: Obj126) of type MT_pre__MatchModel
    self.drawConnections(
(self.obj16045,self.obj16049,[667.0, 320.0, 767.0, 340.0],"true", 2) )
    # Connections for obj16046 (graphObject_: Obj127) of type MT_pre__ApplyModel
    self.drawConnections(
(self.obj16046,self.obj16050,[671.0, 460.0, 769.0, 480.0],"true", 2) )
    # Connections for obj16047 (graphObject_: Obj128) of type MT_pre__Station_T
    self.drawConnections(
 )
    # Connections for obj16048 (graphObject_: Obj129) of type MT_pre__Station_T
    self.drawConnections(
(self.obj16048,self.obj16051,[301.0, 501.0, 301.0, 431.0],"true", 2) )
    # Connections for obj16049 (graphObject_: Obj130) of type MT_pre__match_contains
    self.drawConnections(
(self.obj16049,self.obj16043,[767.0, 340.0, 867.0, 360.0],"true", 2) )
    # Connections for obj16050 (graphObject_: Obj131) of type MT_pre__apply_contains
    self.drawConnections(
(self.obj16050,self.obj16047,[769.0, 480.0, 867.0, 500.0],"true", 2) )
    # Connections for obj16051 (graphObject_: Obj132) of type MT_pre__backward_link
    self.drawConnections(
(self.obj16051,self.obj16044,[301.0, 431.0, 301.0, 361.0],"true", 2) )
    # Connections for obj16052 (graphObject_: Obj133) of type MT_post__match_contains
    self.drawConnections(
(self.obj16052,self.obj16057,[1248.5, 340.0, 1347.0, 360.0],"true", 2) )
    # Connections for obj16053 (graphObject_: Obj134) of type MT_post__MatchModel
    self.drawConnections(
(self.obj16053,self.obj16052,[1150.0, 320.0, 1248.5, 340.0],"true", 2) )
    # Connections for obj16054 (graphObject_: Obj135) of type MT_post__apply_contains
    self.drawConnections(
(self.obj16054,self.obj16058,[1250.5, 480.0, 1347.0, 500.0],"true", 2) )
    # Connections for obj16055 (graphObject_: Obj136) of type MT_post__backward_link
    self.drawConnections(
(self.obj16055,self.obj16057,[1347.0, 430.0, 1347.0, 360.0],"true", 2) )
    # Connections for obj16056 (graphObject_: Obj137) of type MT_post__ApplyModel
    self.drawConnections(
(self.obj16056,self.obj16054,[1154.0, 460.0, 1250.5, 480.0],"true", 2) )
    # Connections for obj16057 (graphObject_: Obj138) of type MT_post__Station_S
    self.drawConnections(
 )
    # Connections for obj16058 (graphObject_: Obj139) of type MT_post__Station_T
    self.drawConnections(
(self.obj16058,self.obj16055,[1347.0, 500.0, 1347.0, 430.0],"true", 2) )
    # Connections for obj16059 (graphObject_: Obj140) of type NAC
    self.drawConnections(
 )
    # Connections for obj16060 (graphObject_: Obj141) of type RHS
    self.drawConnections(
 )
    # Connections for obj16061 (graphObject_: Obj142) of type LHS
    self.drawConnections(
 )

newfunction = build_back_S2S_MDL

loadedMMName = ['MT_pre__SimpleDSLTrans_META', 'MT_post__SimpleDSLTrans_META', 'MoTifRule_META']

atom3version = '0.3'
